package study.datastructure.leetcode.easy.day1;/**
 * @program: datastructure
 * @author: lcy
 * @create: 2024-09-13 14:54
 */

/**
 2024/9/13,
 */

//给你一个下标从 0 开始的整数数组 nums 。如果 nums 中长度为 m 的子数组 s 满足以下条件，我们称它是一个 交替子数组 ：
//
//m 大于 1 。
//s1 = s0 + 1 。
//下标从 0 开始的子数组 s 与数组 [s0, s1, s0, s1,...,s(m-1) % 2] 一样。也就是说，s1 - s0 = 1 ，s2 - s1 = -1 ，s3 - s2 = 1 ，s4 - s3 = -1 ，
// 以此类推，直到 s[m - 1] - s[m - 2] = (-1)m 。
//请你返回 nums 中所有 交替 子数组中，最长的长度，如果不存在交替子数组，请你返回 -1 。
//
//子数组是一个数组中一段连续 非空 的元素序列。
public class Solution1 {
    public void add(){
    }

    public static int alternatingSubarray(int[] nums) {
        if (nums.length<=1) return -1;

        int j=-1; //判断答案
        int m=1; //计数
        int temp=0;

        for (int i = 0; i < nums.length-1; i++) {
            if (nums[i+1]-nums[i]==(-1)*j){ //s1-s0=1 s2-s1=-1
                m++;
                j=j*(-1);
            } else if (m >= 2) { //不连续再判断
                if (m>temp){
                    temp=m;
                }
                if (nums[i+1]-nums[i]==j){ //还可能是新的交替数组开始
                    m=2;
                    j=1;
                }else { //置为初始值
                    m=1;
                    j=-1;
                }
            }
        }
        if (m==1&&temp==0) return -1; //非空检查
        if(m-temp>0){return m;}

        return temp;
    }
    public static int betterSolve(int[] nums){
        int res=-1;
        int n=nums.length;
        int firstIndex = 0;

        for (int i =1; i < n; i++) {
           int length=i-firstIndex+1;
           if (nums[i]-nums[firstIndex]==(length-1)%2){
               res=Math.max(length,res);
           } else {
               if (nums[i] -nums[i-1]==1) { //新的开始
                   firstIndex=i-1;
                   res=Math.max(res,2);
               }else {
                   firstIndex=i;
               }
           }
        }

        return res;
    }
    public static int solve(int[] nums) {
        int res = -1;
        int n = nums.length;
        for (int firstIndex = 0; firstIndex < n; firstIndex++) {
            for (int i = firstIndex + 1; i < n; i++) {
                int length = i - firstIndex + 1;
                if (nums[i] - nums[firstIndex] == (length - 1) % 2) {
                    res = Math.max(res, length);
                } else {
                    break;
                }
            }
        }
        return res;
    }


    public static void main(String[] args) {
       // int[] nums={1,2,1,2,0,1,0,1,0};
      int[] nums={2,3,4,3,4};
       // System.out.println("第一个结果是"+solve(nums)); //100%
        System.out.println("第二个结果是"+betterSolve(nums)); //100%
      // int[] nums={2,5,1};


        //System.out.println("第二个结果是"+alternatingSubarray(nums)); //100%
    }
}
